/**
 * @(#)com.book.base.dao.PageBaseDao
 * 2009-6-15
 * Copyright 2009 
 * Book软件公司, 版权所有 违者必究
 */
package com.site.base.dao;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.hibernate.*;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.impl.CriteriaImpl;
import org.hibernate.transform.ResultTransformer;
import org.springframework.util.Assert;
import org.springframework.orm.hibernate3.HibernateCallback;
import com.site.util.ReflectionUtils;
import com.site.base.dao.PropertyFilter.MatchType;


/**
 * @author 陈雄华
 * @version 1.0
 */
public class PageBaseDao<T> extends BaseDao<T>{

	// 分页查询函数 //

	/**
	 * 分页获取全部对象.
	 */
	public Page<T> getAll(final Page<T> page) {
		return findByCriteria(page);
	}

	/**
	 * 按HQL分页查询.
	 * 不支持自动获取总结果数,需用户另行执行查询.
	 *
	 * @param page 分页参数.仅支持pageSize 和firstResult,忽略其他参数.
	 * @param hql hql语句.
	 * @param values 数量可变的查询参数.
	 *
	 * @return 分页查询结果,附带结果列表及所有查询时的参数.
	 */
	@SuppressWarnings("unchecked")
	public Page<T> find(final Page<T> page, final String hql, final Object... values) {
		Assert.notNull(page, "page不能为空");
		Query q = createQuery(hql, values);
		setPageParameter(q, page);
		List result = q.list();
        if (page.isAutoCount()) {
			int totalCount = calculateRecordCount(hql, values);
			page.setTotalCount(totalCount);
		}
		page.setResult(result);
		return page;
	}

    /**
	 * 按HQL分页查询.
	 * 不支持自动获取总结果数,需用户另行执行查询.
	 *
	 * @param page 分页参数.仅支持pageSize 和firstResult,忽略其他参数.
	 * @param hql hql语句.
	 * @param values 数量可变的查询参数.
	 *
	 * @return 分页查询结果,附带结果列表及所有查询时的参数.
	 */
	@SuppressWarnings("unchecked")
	public Page<T> find(final Page<T> page, final String hql, final Map<String, Object> values) {
		Assert.notNull(page, "page不能为空");
		Query q = createQuery(hql, values);
		setPageParameter(q, page);
         List result = q.list();
        if (page.isAutoCount()) {
			int totalCount = calculateRecordCount(hql, values);
			page.setTotalCount(totalCount);
		}
		page.setResult(result);
		return page;
	}

    /**
     * 根据HQL语句，分页查询结果。
     * 如果参数paging不为null，则对记录集进行分页查询，并计算记录集总数。
     * add by wenjg 2009-06-21
     * @param hql
     * @param paging
     * @return
     */
    @SuppressWarnings("unchecked")
    public Page<T> find(final Page<T> page, final String hql) {
        return find(page, hql, (Object[])null);
    }

	/**
	 * 按Criteria分页查询.
	 *
	 * @param page 分页参数.支持pageSize、firstResult和orderBy、order、autoCount参数.
	 *             其中autoCount指定是否动态获取总结果数.
	 * @param criterions 数量可变的Criterion.
	 *
	 * @return 分页查询结果.附带结果列表及所有查询时的参数.
	 */
	@SuppressWarnings("unchecked")
	public Page<T> findByCriteria(final Page<T> page, final Criterion... criterions) {
		Assert.notNull(page, "page不能为空");
		Criteria c = createCriteria(criterions);
		if (page.isAutoCount()) {
			int totalCount = countCriteriaResult(c);
			page.setTotalCount(totalCount);
		}

		setPageParameter(c, page);
		List result = c.list();
		page.setResult(result);
		return page;
	}

	/**
	* 设置分页参数到Query对象,辅助函数.
	*/
	protected Query setPageParameter(final Query q, final Page<T> page) {
		q.setFirstResult(page.getFirst());
		q.setMaxResults(page.getPageSize());
		return q;
	}

	/**
	 * 设置分页参数到Criteria对象,辅助函数.
	 */
	protected Criteria setPageParameter(final Criteria c, final Page<T> page) {
		c.setFirstResult(page.getFirst());
		c.setMaxResults(page.getPageSize());

		if (page.isOrderBySetted()) {
			String[] orderByArray = StringUtils.split(page.getOrderBy(), ',');
			String[] orderArray = StringUtils.split(page.getOrder(), ',');

			Assert.isTrue(orderByArray.length == orderArray.length, "分页多重排序参数中,排序字段与排序方向的个数不相等");

			for (int i = 0; i < orderByArray.length; i++) {
				if (Page.ASC.equals(orderArray[i])) {
					c.addOrder(Order.asc(orderByArray[i]));
				} else {
					c.addOrder(Order.desc(orderByArray[i]));
				}
			}
		}
		return c;
	}

	/**
	 * 执行count查询获得本次Criteria查询所能获得的对象总数.
	 */
	@SuppressWarnings("unchecked")
	protected int countCriteriaResult(final Criteria c) {
		CriteriaImpl impl = (CriteriaImpl) c;

		// 先把Projection、ResultTransformer、OrderBy取出来,清空三者后再执行Count操作
		Projection projection = impl.getProjection();
		ResultTransformer transformer = impl.getResultTransformer();

		List<CriteriaImpl.OrderEntry> orderEntries = null;
		try {
			orderEntries = (List) ReflectionUtils.getFieldValue(impl, "orderEntries");
			ReflectionUtils.setFieldValue(impl, "orderEntries", new ArrayList());
		} catch (Exception e) {
			logger.error("不可能抛出的异常:{}", e.getMessage());
		}

		// 执行Count查询
		int totalCount = (Integer) c.setProjection(Projections.rowCount()).uniqueResult();

		// 将之前的Projection,ResultTransformer和OrderBy条件重新设回去
		c.setProjection(projection);

		if (projection == null) {
			c.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
		}
		if (transformer != null) {
			c.setResultTransformer(transformer);
		}
		try {
			ReflectionUtils.setFieldValue(impl, "orderEntries", orderEntries);
		} catch (Exception e) {
			logger.error("不可能抛出的异常:{}", e.getMessage());
		}

		return totalCount;
	}

	// 属性条件查询函数 //

	/**
	 * 按属性查找对象列表,支持多种匹配方式.
	 *
	 * @param matchType 目前支持的取值为"EQUAL"与"LIKE".
	 */
	public List<T> findBy(final String propertyName, final Object value, final String matchTypeStr) {
		PropertyFilter.MatchType matchType = Enum.valueOf(MatchType.class, matchTypeStr);
		Criterion criterion = buildPropertyCriterion(propertyName, value, matchType);
		return find(criterion);
	}

	/**
	 * 按属性过滤条件列表查找对象列表.
	 */
	public List<T> find(final List<PropertyFilter> filters) {
		Criterion[] criterions = buildFilterCriterions(filters);
		return find(criterions);
	}

	/**
	 * 按属性过滤条件列表分页查找对象.
	 */
	public Page<T> find(final Page<T> page, final List<PropertyFilter> filters) {
		Criterion[] criterions = buildFilterCriterions(filters);
		return findByCriteria(page, criterions);
	}

	/**
	 * 按属性条件列表创建Criterion数组,辅助函数.
	 */
	protected Criterion[] buildFilterCriterions(final List<PropertyFilter> filters) {
		List<Criterion> criterionList = new ArrayList<Criterion>();
		for (PropertyFilter filter : filters) {
			String propertyName = filter.getPropertyName();

			boolean multiProperty = StringUtils.contains(propertyName, PropertyFilter.OR_SEPARATOR);
			if (!multiProperty) { //properNameName中只有一个属性的情况.
				Criterion criterion = buildPropertyCriterion(propertyName, filter.getValue(), filter.getMatchType());
				criterionList.add(criterion);
			} else {//properName中包含多个属性的情况,进行or处理.
				Disjunction disjunction = Restrictions.disjunction();
				String[] params = StringUtils.split(propertyName, PropertyFilter.OR_SEPARATOR);

				for (String param : params) {
					Criterion criterion = buildPropertyCriterion(param, filter.getValue(), filter.getMatchType());
					disjunction.add(criterion);
				}
				criterionList.add(disjunction);
			}
		}
		return criterionList.toArray(new Criterion[criterionList.size()]);
	}

	/**
	 * 按属性条件参数创建Criterion,辅助函数.
	 */
	protected Criterion buildPropertyCriterion(final String propertyName, final Object value, final MatchType matchType) {
		Assert.hasText(propertyName, "propertyName不能为空");
		Criterion criterion = null;

		if (MatchType.EQ.equals(matchType)) {
			criterion = Restrictions.eq(propertyName, value);
		}
		else if (MatchType.LIKE.equals(matchType)) {
			criterion = Restrictions.like(propertyName, (String) value, MatchMode.ANYWHERE);
		}
        else if (MatchType.STARTLIKE.equals(matchType)) {
			criterion = Restrictions.like(propertyName, (String) value, MatchMode.START);
		}
        else if (MatchType.ENDLIKE.equals(matchType)) {
			criterion = Restrictions.like(propertyName, (String) value, MatchMode.END);
		}
        else if(MatchType.LT.equals(matchType)){
             Restrictions.lt(propertyName, value);
        }
        else if(MatchType.LTE.equals(matchType)){
             Restrictions.le(propertyName, value);
        }
        else if(MatchType.GT.equals(matchType)){
             Restrictions.gt(propertyName, value);
        }
        else if(MatchType.GTE.equals(matchType)){
             Restrictions.ge(propertyName, value);
        }

		return criterion;
	}

    /**
     * 截取用于计算记录集总数的HQL语句的起始保留字“from”
     */
    private static final String START_RESERVE_WORDS = "from";
    /**
     * 计算记录集总数的HQL语法前缀
     */
    private static final String SELECT_COUNT_PREFIX = "select count(*) ";
    /**
     * 计算HQL总条数的方法
     * @param hql
     * @return
     */
    public static String generateCountStr(String hql) {
        String lowerCaseHql = hql.toLowerCase();
        int start = lowerCaseHql.indexOf(START_RESERVE_WORDS);
        int end = hql.length();

        //判断是否包含保留字
        for (String key : END_RESERVE_WORDS) {
            if (lowerCaseHql.indexOf(key) > -1) {
                end = lowerCaseHql.indexOf(key);
                break;
            }
        }

        return SELECT_COUNT_PREFIX + hql.substring(start, end);
    }

    /**
     * 截取用于计算记录集总数的HQL语句的起始保留字数组。
     * 由于这些保留字在HQL语句中均为可选，因此要依次判断HQL语句中是否存在这些保留字。如果发现存在
     * 这些保留字中的任何一个（依次），便确定用于计算记录集总数的HQL语句的结束位置；如果未不存在
     * 这些保留字，则结束位置为原HQL的长度。
     */
    private static final String[] END_RESERVE_WORDS = {" group", " having", " order"};

    protected int calculateRecordCount(String hql, Map<String, Object> namedParamMap) {
        String countHql = generateCountStr(hql);
        return uniqueIntResult(countHql, namedParamMap);
    }

      /**
     * 根据named param获取唯一整数结果。
     *
     * @param hql
     * @param namedParamMap
     * @return
     */
    public int uniqueIntResult(String hql, Map<String, Object> namedParamMap) {
        return returnIntValueFromRet(uniqueResult(hql, namedParamMap));
    }
    /**
     * 根据数据库查询结果，返回合适的整数数值。
     *
     * @param obj
     * @return
     */
    private int returnIntValueFromRet(Object obj) {

        if (obj instanceof Long) {
            Long ret = (Long)obj;
            return (ret == null) ? 0 : ret.intValue();
        }

        if (obj instanceof Integer) {
            Integer ret = (Integer)obj;
            return (ret == null) ? 0 : ret.intValue();
        }

        return 0;
    }

        /**
     * 根据HQL语句及参数值，获取唯一结果。
     *
     * @param hql
     * @param paramValues
     * @return
     */
    public Object uniqueResult(final String hql, final Map paramValues) {
         Query q = createQuery(hql, paramValues);
         return q.uniqueResult();
    }

     /**
     * 根据参数数组计算符合条件的记录集总数。
     *
     * @param hql
     * @param paramValues
     * @return
     */
    protected int calculateRecordCount(final String hql, final Object[] paramValues) {
        String countHql = generateCountStr(hql);
        return uniqueIntResult(countHql, paramValues);
    }

    /**
     * 根据HQL语句及参数值，获取唯一整数结果。如果没有结果，则返回为0。
     *
     * @param hql
     * @param paramValues
     * @return
     */
    public int uniqueIntResult(String hql, Object[] paramValues) {
        return returnIntValueFromRet(uniqueResult(hql, paramValues));
    }

        /**
     * 根据HQL语句及参数值，获取唯一结果。
     *
     * @param hql
     * @param paramValues
     * @return
     */
    public Object uniqueResult(final String hql, final Object[] paramValues) {
        Query q = createQuery(hql, paramValues);
         return q.uniqueResult();
    }
}
